package com.linwen.javase.new8.optional;

import org.junit.Test;

import java.util.Optional;

/**
 * @author : linwen
 * @date : 下午10:27 2021/9/26
 */
public class OptionalsTest {


    /**
     * @Author zero
     * @Description optional解决什么问题，解决不了什么问题
     * @Date 8:04 AM 2024/1/19
     * @Param
     * @return
     **/
    @Test
    public void test() {

        // 传统的写法，对返回值user再次做空判断
        OptionalUserRepository resporstory = new OptionalUserRepository();
        OptionalUser user = resporstory.getUser(null);
        if (user != null) {
            System.out.println(user.getName());
        }else {
            System.out.println("user is null");
        }
        // 依旧是命令式编程的写法
        Optional<OptionalUser> user2 = resporstory.getUser2(null);
        if (user2.isPresent()) {
            System.out.println(user2.get().getName());
        }else {
            System.out.println("user is null");
        }

        // 应该使用的方法,即我们应该要去消费此对象才使用
        OptionalUser usresult = user2.orElse(new OptionalUser());
        OptionalUser usresult1 = user2.orElseGet(()-> new OptionalUser());
        OptionalUser usresult2 = user2.orElseThrow(() -> new RuntimeException("user is null"));
        user2.ifPresent(opUser->{System.out.println(opUser.getName());});
        user2.map(OptionalUser::getName).ifPresent(System.out::println);
    }


    /**
     * Optional 对象的创建
     * */
    @Test
    public void test1(){
        Integer value1 = null;
        Integer value2 = new Integer(10);

        // Optional.ofNullable - 允许传递为 null 参数
        Optional<Integer> a = Optional.ofNullable(value1);

        // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
        Optional<Integer> b = Optional.of(value2);

        // Optional.empty()   静态方法创建一个空的Optional对象
        Optional<Object> value3 = Optional.empty();
    }

    /**
     * Optional 对象的消费
     * */
    @Test
    public void test2() throws Throwable {
        // ifPresent 若对象值存在则执行消费
        Integer value1 = null;
        Optional<Integer> a = Optional.ofNullable(value1);
        a.ifPresent(System.out::println);
        // get 获取值必须存在，若不存在则抛出异常 No value present
        System.out.println(a.get());
        // orElse 获取值，若值不存在，取默认值
        System.out.println(a.orElse(0));
        // orElseGet 若值不存在，从另一个方法中获取
        System.out.println(a.orElseGet(() -> 10));
        // orElseThrow 若值不存在，抛出一个指定的异常
        System.out.println(a.orElseThrow(() -> new RuntimeException("自定义异常")));

    }
    /**
     * 过滤
     * */
    @Test
    public void test3(){
        Integer value1 = 11;
        Optional<Integer> a = Optional.ofNullable(value1);
        // 如果不符合filter  则返回新的Optional对象，且没有值。
        a.filter(temp->temp>10).ifPresent(System.out::println);
    }

    /**
     * 判断,Optional中是否有包装值
     * */
    @Test
    public void test4(){
        Integer value1 = 11;
        Optional<Integer> a = Optional.ofNullable(value1);
        System.out.println(a.isPresent());
    }

    /**
     * 数据转换
     * */
    @Test
    public void test5(){
        Integer value1 = 11;
        Optional<Integer> a = Optional.ofNullable(value1);
        Optional<String> s = a.map(integer -> "hello");
        s.ifPresent(System.out::println);
    }
    private static Integer sum(Optional<Integer> a, Optional<Integer> b){

        // Optional.isPresent - 判断值是否存在

        System.out.println("第一个参数值存在: " + a.isPresent());
        System.out.println("第二个参数值存在: " + b.isPresent());

        // Optional.orElse - 如果值存在，返回它，否则返回默认值
        Integer value1 = a.orElse(new Integer(0));

        //Optional.get - 获取值，值需要存在
        Integer value2 = b.get();
        return value1 + value2;
    }
}
